home *** CD-ROM | disk | FTP | other *** search
/ Chip: 2001 Haziran / CHIP Haziran2001.iso / prog / haziran / 19 / setup.exe / data.z / amccdiag.c < prev    next >
Encoding:
C/C++ Source or Header  |  2001-04-11  |  19.8 KB  |  635 lines
  1. /////////////////////////
  2. /////// AMCCDIAG.C //////
  3. /////////////////////////
  4.  
  5. #include "../../include/windrvr.h"
  6. #include "../lib/amcclib.h"
  7. #include "../../samples/shared/pci_diag_lib.h"
  8. #include <stdio.h>
  9.  
  10. // input of command from user
  11. static char line[256];
  12.  
  13. void AMCC_EditReg(AMCCHANDLE hAmcc)
  14. {
  15.     struct 
  16.     {
  17.         CHAR *name;
  18.         DWORD dwOffset;
  19.         DWORD dwBytes;
  20.         DWORD dwVal;
  21.     } fields[30];
  22.  
  23.     int cmd;
  24.     int i;
  25.     int field_count;
  26.  
  27.     i = 0;
  28.     fields[i].name = "OMB1"; fields[i].dwOffset = 0x0; fields[i++].dwBytes = 4;
  29.     fields[i].name = "OMB2"; fields[i].dwOffset = 0x4; fields[i++].dwBytes = 4;
  30.     fields[i].name = "OMB3"; fields[i].dwOffset = 0x8; fields[i++].dwBytes = 4;
  31.     fields[i].name = "OMB4"; fields[i].dwOffset = 0xc; fields[i++].dwBytes = 4;
  32.     fields[i].name = "IMB1"; fields[i].dwOffset = 0x10; fields[i++].dwBytes = 4;
  33.     fields[i].name = "IMB2"; fields[i].dwOffset = 0x14; fields[i++].dwBytes = 4;
  34.     fields[i].name = "IMB3"; fields[i].dwOffset = 0x18; fields[i++].dwBytes = 4;
  35.     fields[i].name = "IMB4"; fields[i].dwOffset = 0x1c; fields[i++].dwBytes = 4;
  36.     fields[i].name = "FIFO"; fields[i].dwOffset = 0x20; fields[i++].dwBytes = 4;
  37.     fields[i].name = "MWAR"; fields[i].dwOffset = 0x24; fields[i++].dwBytes = 4;
  38.     fields[i].name = "MWTCR"; fields[i].dwOffset = 0x28; fields[i++].dwBytes = 4;
  39.     fields[i].name = "MRAR"; fields[i].dwOffset = 0x2c; fields[i++].dwBytes = 4;
  40.     fields[i].name = "MRTCR"; fields[i].dwOffset = 0x30; fields[i++].dwBytes = 4;
  41.     fields[i].name = "MBEF"; fields[i].dwOffset = 0x34; fields[i++].dwBytes = 4;
  42.     fields[i].name = "INTCSR"; fields[i].dwOffset = 0x38; fields[i++].dwBytes = 4;
  43.     fields[i].name = "BMCSR"; fields[i].dwOffset = 0x3c; fields[i++].dwBytes = 4;
  44.     field_count = i;
  45.     do
  46.     {
  47.         int row;
  48.         int col;
  49.         int row_count = field_count/2 + field_count%2;
  50.  
  51.         printf ("\n");
  52.         printf ("Edit 5933 operation registers\n");
  53.         printf ("--------------------------------\n");
  54.         for (row = 0; row<row_count; row++)
  55.         {
  56.             for (col = 0; col<=1; col++)
  57.             {
  58.                 if (col==0) i = row;
  59.                 else i = row + row_count;
  60.  
  61.                 if (i<field_count)
  62.                 {
  63.                     char buf[10];
  64.                     if (fields[i].dwOffset!=FIFO_ADDR)
  65.                     {
  66.                         fields[i].dwVal = AMCC_ReadRegDWord(hAmcc, fields[i].dwOffset);
  67.                         sprintf(buf, "%08x",fields[i].dwVal);
  68.                     }
  69.                     else
  70.                         strcpy (buf,"Write   ");
  71.                     printf ("%2d. %6s : %s     ",i+1, fields[i].name, buf);
  72.                 }
  73.                 if (col==1) printf ("\n");
  74.             }
  75.         }
  76.  
  77.         printf ("20. FIFO read.\n");
  78.         printf ("99. Back to main menu\n");
  79.         printf ("Enter option: ");
  80.         cmd = 0;
  81.         fgets(line, sizeof(line), stdin);
  82.         sscanf (line, "%d",&cmd);
  83.         if (cmd>=1 && cmd <=16)
  84.         {
  85.             i = cmd-1;
  86.             printf ("Enter value to write to %s register (or 'X' to cancel): ",fields[i].name);
  87.             fgets(line, sizeof(line), stdin);
  88.             if (toupper (line[0])!='X')
  89.             {
  90.                 DWORD dwVal;
  91.                 dwVal = 0;
  92.                 sscanf(line,"%x",&dwVal);
  93.                 if ((dwVal>0xff && fields[i].dwBytes==1)|| 
  94.                     (dwVal>0xffff && fields[i].dwBytes==2)|| 
  95.                     (dwVal>0xffffff && fields[i].dwBytes==3))
  96.                 {
  97.                     printf ("Error: value too big for register\n");
  98.                 }
  99.                 else
  100.                 {
  101.                     AMCC_WriteRegDWord(hAmcc, fields[i].dwOffset, dwVal);
  102.                 }
  103.             }
  104.         }
  105.         else if (cmd==20)
  106.         {
  107.             DWORD dwVal;
  108.  
  109.             dwVal = AMCC_ReadRegDWord(hAmcc, BMCSR_ADDR);
  110.             if (dwVal & BIT5) 
  111.             {
  112.                 printf ("Could not read FIFO - inbound FIFO empty\n");
  113.             }
  114.             else
  115.             {
  116.                 dwVal = AMCC_ReadRegDWord(hAmcc, FIFO_ADDR);
  117.                 printf ("FIFO : %08x\n", dwVal);
  118.             }
  119.         }
  120.     } while (cmd!=99);
  121. }
  122.  
  123. BOOL Diag_test_OGMB(AMCCHANDLE hAmcc, DWORD nOGMB, DWORD nByte, DWORD nTestSize, DWORD dwVal)
  124. {
  125.     DWORD dwValRead;
  126.     DWORD dwAddr = OMB1_ADDR + nOGMB*4 + nByte;
  127.     DWORD dwMBEFMask;
  128.     // reset MBEF
  129.     AMCC_WriteRegDWord(hAmcc, BMCSR_ADDR, AMCC_ReadRegDWord(hAmcc, BMCSR_ADDR) | BIT27);
  130.     if (AMCC_ReadRegDWord(hAmcc, MBEF_ADDR)!=0) 
  131.     {
  132.         printf ("MBEF doesn't reset\n");
  133.         return FALSE;
  134.     }
  135.  
  136.     switch (nTestSize)
  137.     {
  138.     case 1:
  139.         AMCC_WriteRegByte(hAmcc, dwAddr, (BYTE) dwVal);
  140.         dwValRead = AMCC_ReadRegByte(hAmcc, dwAddr); 
  141.         dwMBEFMask = 0x1;
  142.         break;
  143.     case 2:
  144.         AMCC_WriteRegWord(hAmcc, dwAddr, (WORD) dwVal);
  145.         dwValRead = AMCC_ReadRegWord(hAmcc, dwAddr);
  146.         dwMBEFMask = 0x3;
  147.         break;
  148.     case 4:
  149.         AMCC_WriteRegDWord(hAmcc, dwAddr, dwVal);
  150.         dwValRead = AMCC_ReadRegDWord(hAmcc, dwAddr);
  151.         dwMBEFMask = 0xf;
  152.         break;
  153.     }
  154.     if (dwVal!=dwValRead) 
  155.     {
  156.         printf ("OGMB write->read gave different values\n");
  157.         return FALSE;
  158.     }
  159.  
  160.     dwValRead = AMCC_ReadRegDWord(hAmcc, MBEF_ADDR);
  161.     if (dwValRead != (dwMBEFMask << (nOGMB*4 + nByte)))
  162.     {
  163.         printf ("MBEF didn't set bits after writing to OGMB\n");
  164.         return FALSE;
  165.     }
  166.  
  167.     return TRUE;
  168. }
  169.  
  170. void AMCC_RunDiag(AMCCHANDLE hAmcc)
  171. {
  172.     int i,j;
  173.     DWORD dwVal;
  174.     BOOL fTestOk, fTestAllOk;
  175.  
  176.     printf ("\n");
  177.     printf ("Run diagnostics\n");
  178.     printf ("---------------\n");
  179.     printf ("\n");
  180.     printf ("Testing OGMB: ");
  181.  
  182.     fTestAllOk = TRUE;
  183.     // test OGMB1-4 registers
  184.     fTestOk = TRUE;
  185.     for (i=0; i<4 && fTestOk; i++)
  186.     {
  187.         // test as BYTES
  188.         for (j=0; j<4 && fTestOk; j++)
  189.         {
  190.             for (dwVal=0; dwVal<=0xff && fTestOk; dwVal++)
  191.             {
  192.                 if (!Diag_test_OGMB(hAmcc, i, j, 1, dwVal)) fTestOk = FALSE;
  193.             }
  194.         }
  195.  
  196.         // test as WORDS
  197.         for (j=0; j<2 && fTestOk; j++)
  198.         {
  199.             for (dwVal=0; dwVal<=0xf000 && fTestOk; dwVal+=0xf9)
  200.             {
  201.                 if (!Diag_test_OGMB(hAmcc, i, j*2, 2, dwVal)) fTestOk = FALSE;
  202.             }
  203.         }
  204.  
  205.         // test as DWORD
  206.         for (dwVal=0; dwVal<=0xf0000000 && fTestOk; dwVal+=0x00f98765)
  207.         {
  208.             if (!Diag_test_OGMB(hAmcc, i, 0, 4, dwVal)) fTestOk = FALSE;
  209.         }
  210.     }
  211.  
  212.     if (fTestOk)
  213.     {
  214.         printf ("Passed.\n");
  215.     }
  216.     else
  217.     {
  218.         printf ("Failed!\n");
  219.         fTestAllOk = FALSE;
  220.     }
  221.  
  222.     // test FIFO
  223.     fTestOk = TRUE;
  224.     printf ("FIFO test: ");
  225.     // make sure FIFO is empty
  226.     for (i=0; i<9; i++)
  227.     {
  228.         if (AMCC_ReadRegDWord(hAmcc, BMCSR_ADDR) & BIT5) 
  229.             break;
  230.         AMCC_ReadRegDWord(hAmcc, FIFO_ADDR);
  231.     }
  232.     if (i==9)
  233.     {
  234.         printf ("Could not empty FIFO (performed 8 reads already)\n");
  235.         fTestOk = FALSE;
  236.     }
  237.     else
  238.     {
  239.         DWORD dwPattern[8] = 
  240.         {
  241.             0x12345678, 0x87654321, 0xabcdef90, 0x09fedcba, 
  242.             0x0f1e2d3c, 0x4b5a6978, 0x8796a5b4, 0xc3d2e1f0
  243.         };
  244.  
  245.         // turn on FIFO loopback
  246.         AMCC_WriteRegDWord(hAmcc, BMCSR_ADDR, BIT28 | AMCC_ReadRegDWord(hAmcc, BMCSR_ADDR));
  247.  
  248.         for (i=0; i<8; i++)
  249.         {
  250.             AMCC_WriteRegDWord(hAmcc, FIFO_ADDR, dwPattern[i]);
  251.         }
  252.  
  253.         for (i=0; i<8 && fTestOk; i++)
  254.         {
  255.             DWORD dwFifoStatus;
  256.  
  257.             dwFifoStatus = AMCC_ReadRegDWord(hAmcc, BMCSR_ADDR) & (BIT3 | BIT4 | BIT5);
  258.             if (i==0 && dwFifoStatus!=(BIT3 | BIT4))
  259.             {
  260.                 printf ("BMCSR fifo status error (FIFO full)\n");
  261.                 fTestOk = FALSE;
  262.             }
  263.             else if (i>0 && i<=4 && dwFifoStatus!=(BIT4))
  264.             {
  265.                 printf ("BMCSR fifo status error (FIFO half full)\n");
  266.                 fTestOk = FALSE;
  267.             }
  268.             else if (i>4 && dwFifoStatus!=0)
  269.             {
  270.                 printf ("BMCSR fifo status error (FIFO half emtpy)\n");
  271.                 fTestOk = FALSE;
  272.             }
  273.  
  274.             if (AMCC_ReadRegDWord(hAmcc, FIFO_ADDR)!=dwPattern[i])
  275.             {
  276.                 printf ("FIFO read different value from what was written\n");
  277.                 fTestOk = FALSE;
  278.             }
  279.         }
  280.         if (fTestOk)
  281.         {
  282.             if ((AMCC_ReadRegDWord(hAmcc, BMCSR_ADDR) & (BIT3 | BIT4 | BIT5))!=BIT5)
  283.             {
  284.                 printf ("BMCSR error in status (FIFO empty)");
  285.                 fTestOk = FALSE;
  286.             }
  287.         }
  288.     }
  289.  
  290.     if (fTestOk)
  291.     {
  292.         printf ("Passed.\n");
  293.     }
  294.     else
  295.     {
  296.         printf ("Failed!\n");
  297.         fTestAllOk = FALSE;
  298.     }
  299.     
  300.     // Add test to write to the address MRAR MWAR MRTCR MWTCR (also status)
  301.  
  302.     if (fTestAllOk)
  303.     {
  304.         printf ("Board passed Diagnostic test.\n");
  305.     }
  306.     else
  307.     {
  308.         printf ("Diagnostic test failed!\n");
  309.     }
  310. }
  311.  
  312. char *AMCC_GetAddrRangeName(AMCC_ADDR addrSpace)
  313. {
  314.     return 
  315.         addrSpace==AMCC_ADDR_SPACE0 ? "Addr Space 0 - (BAR1)" :
  316.         addrSpace==AMCC_ADDR_SPACE1 ? "Addr Space 1 - (BAR2)" :
  317.         addrSpace==AMCC_ADDR_SPACE2 ? "Addr Space 2 - (BAR3)" :
  318.         addrSpace==AMCC_ADDR_SPACE3 ? "Addr Space 3 - (BAR4)" :
  319.         addrSpace==AMCC_ADDR_NOT_USED ? "Not used Addr Space - (BAR5)" : "Invalid";
  320. }
  321.  
  322. void AMCC_BoardAccess(AMCCHANDLE hAmcc)
  323. {
  324.     int cmd, cmd2, i;
  325.     typedef enum {AMCC_MODE_BYTE, AMCC_MODE_WORD, AMCC_MODE_DWORD} AMCC_MODE;
  326.     DWORD addr, data;
  327.     AMCC_ADDR ad_sp = AMCC_ADDR_SPACE0;
  328.     AMCC_MODE ad_mode = AMCC_MODE_DWORD;
  329.  
  330.     for (; ad_sp<AMCC_ADDR_NOT_USED && !AMCC_IsAddrSpaceActive(hAmcc, ad_sp); ad_sp++)
  331.     if (ad_sp==AMCC_ADDR_NOT_USED)
  332.     {
  333.         printf ("No active memory spaces on board!\n");
  334.         return;
  335.     }
  336.  
  337.     do
  338.     {
  339.         printf ("\n");
  340.         printf ("Access the board's memory ranges\n");
  341.         printf ("--------------------------------\n");
  342.         printf ("1. Change active memory space: %s\n",AMCC_GetAddrRangeName(ad_sp));
  343.         printf ("2. Toggle active mode: %s\n", 
  344.             ad_mode==AMCC_MODE_BYTE ? "BYTE (8 bit)" :
  345.             ad_mode==AMCC_MODE_WORD ? "WORD (16 bit)" : "DWORD (32 bit)");
  346.         printf ("3. Read from board\n");
  347.         printf ("4. Write to board\n");
  348.         printf ("99. Back to main menu\n");
  349.         printf ("\n");
  350.         printf ("Enter option: ");
  351.         cmd = 0;
  352.         fgets(line, sizeof(line), stdin);
  353.         sscanf (line, "%d",&cmd);
  354.         switch (cmd)
  355.         {
  356.         case 1:
  357.             printf ("Choose memory space:\n");
  358.             printf ("--------------------\n");
  359.             for (i=AMCC_ADDR_SPACE0; i<AMCC_ADDR_NOT_USED; i++)
  360.             {
  361.                 printf ("%d. %s", i, AMCC_GetAddrRangeName(i));
  362.                 if (AMCC_IsAddrSpaceActive(hAmcc, i)) printf ("\n");
  363.                 else printf (" - space not active\n");
  364.             }
  365.             printf ("Enter option: ");
  366.             cmd2 = 99;
  367.             fgets(line, sizeof(line), stdin);
  368.             sscanf (line, "%d",&cmd2);
  369.             if (cmd2>=AMCC_ADDR_SPACE0 && cmd2<AMCC_ADDR_NOT_USED)
  370.             {
  371.                 int new_ad_sp = cmd2;
  372.                 if (AMCC_IsAddrSpaceActive(hAmcc, new_ad_sp)) ad_sp = new_ad_sp;
  373.                 else printf ("Chosen space not active!\n");
  374.             }
  375.             break;
  376.         case 2:
  377.             ad_mode = (ad_mode + 1) % 3;
  378.             break;
  379.         case 3:
  380.             printf ("Enter offset to read from: ");
  381.             fgets(line, sizeof(line), stdin);
  382.             sscanf (line, "%x", &addr);
  383.             switch (ad_mode)
  384.             {
  385.             case AMCC_MODE_BYTE:
  386.                 data = AMCC_ReadByte(hAmcc, ad_sp, addr);
  387.                 break;
  388.             case AMCC_MODE_WORD:
  389.                 data = AMCC_ReadWord(hAmcc, ad_sp, addr);
  390.                 break;
  391.             case AMCC_MODE_DWORD:
  392.                 data = AMCC_ReadDWord(hAmcc, ad_sp, addr);
  393.                 break;
  394.             }
  395.             printf ("Value read: %x\n", data);
  396.             break;
  397.         case 4:
  398.             printf ("Enter offset to write to: ");
  399.             fgets(line, sizeof(line), stdin);
  400.             sscanf (line, "%x", &addr);
  401.             printf ("Enter data to write %s: ",
  402.                 ad_mode==AMCC_MODE_BYTE ? "BYTE (8 bit)" :
  403.                 ad_mode==AMCC_MODE_WORD ? "WORD (16 bit)" : "DWORD (32 bit)");
  404.             fgets(line, sizeof(line), stdin);
  405.             sscanf (line, "%x",&data);
  406.             switch (ad_mode)
  407.             {
  408.             case AMCC_MODE_BYTE:
  409.                 AMCC_WriteByte(hAmcc, ad_sp, addr, (BYTE) data);
  410.                 break;
  411.             case AMCC_MODE_WORD:
  412.                 AMCC_WriteWord(hAmcc, ad_sp, addr, (WORD) data);
  413.                 break;
  414.             case AMCC_MODE_DWORD:
  415.                 AMCC_WriteDWord(hAmcc, ad_sp, addr, data);
  416.                 break;
  417.             }
  418.             break;
  419.         }
  420.     } while (cmd!=99);
  421. }
  422.  
  423. void WINAPI AMCC_IntHandlerRoutine(AMCCHANDLE hAmcc, AMCC_INT_RESULT *intResult)
  424. {
  425.     printf ("Got interrupt number %d\n", intResult->dwCounter);
  426. }
  427.  
  428. void AMCC_EnableDisableInterrupts(AMCCHANDLE hAmcc)
  429. {
  430.     int cmd;
  431.  
  432.     printf ("WARNING!!!\n");
  433.     printf ("----------\n");
  434.     printf ("Your hardware has level sensitive interrupts.\n");
  435.     printf ("You must modify the source code of AMCC_IntEnable(), in the file amcclib.c,\n");
  436.     printf ("to acknowledge the interrupt before enabling interrupts.\n");
  437.     printf ("Without this modification, your PC will HANG upon interrupt!\n");
  438.  
  439.     do
  440.     {
  441.         printf ("Enable / Disable interrupts\n");
  442.         printf ("---------------------------\n");
  443.         printf ("1. %s interrupts\n", AMCC_IntIsEnabled(hAmcc) ? "Disable" : "Enable");
  444.         printf ("99. Back to main menu\n");
  445.         printf ("\n");
  446.         printf ("Enter option: ");
  447.         cmd = 0;
  448.         fgets(line, sizeof(line), stdin);
  449.         sscanf (line, "%d",&cmd);
  450.         switch (cmd)
  451.         {
  452.         case 1:
  453.             if (AMCC_IntIsEnabled(hAmcc))
  454.             {
  455.                 printf ("Disabling interrupt Int\n");
  456.                 AMCC_IntDisable(hAmcc);
  457.             }
  458.             else
  459.             {
  460.                 printf ("Enabling interrupts\n");
  461.                 if (!AMCC_IntEnable(hAmcc, AMCC_IntHandlerRoutine))
  462.                     printf ("failed enabling interrupts\n");
  463.             }
  464.             break;
  465.         }
  466.     } while (cmd!=99);
  467. }
  468.  
  469. void AMCC_AccessNVRAM(AMCCHANDLE hAmcc)
  470. {
  471.     int cmd;
  472.     DWORD dwAddr;
  473.  
  474.     do
  475.     {
  476.         printf ("\n");
  477.         printf ("Access the board's nvRAM\n");
  478.         printf ("------------------------\n");
  479.         printf ("1. Read nvRAM data\n");
  480.         printf ("2. Program nvRAM\n");
  481.         printf ("99. Back to main menu\n");
  482.         printf ("\n");
  483.         printf ("Enter option: ");
  484.         cmd = 0;
  485.         fgets(line, sizeof(line), stdin);
  486.         sscanf (line, "%d",&cmd);
  487.         switch (cmd)
  488.         {
  489.         case 1:
  490.             printf ("Read nvRAM\n");
  491.             for (dwAddr=0; dwAddr<AMCC_NVRAM_SIZE; dwAddr++)
  492.             {
  493.                 BYTE data;
  494.                 if ((dwAddr % 16) == 0) printf ("%04x- ", dwAddr);
  495.                 if (!AMCC_ReadNVByte(hAmcc, dwAddr, &data))
  496.                 {
  497.                     printf ("\nerror while reading nvRAM!\n");
  498.                     break;
  499.                 }
  500.                 printf (" %02x",data);
  501.                 if ((dwAddr % 16) == 15) printf ("\n");
  502.             }
  503.             break;
  504.         case 2:
  505.             printf ("This option is not yet implemented\n");
  506.             break;
  507.         }
  508.     } while (cmd!=99);
  509. }
  510.  
  511. AMCCHANDLE AMCC_LocateAndOpenBoard(DWORD dwVendorID, DWORD dwDeviceID, BOOL fUseInt)
  512. {
  513.     DWORD cards, my_card;
  514.     AMCCHANDLE hAmcc = NULL;
  515.  
  516.     if (dwVendorID==0)
  517.     {
  518.         printf ("Enter VendorID: ");
  519.         fgets(line, sizeof(line), stdin);
  520.         sscanf (line, "%x",&dwVendorID);
  521.         if (dwVendorID==0) return NULL;
  522.  
  523.         printf ("Enter DeviceID: ");
  524.         fgets(line, sizeof(line), stdin);
  525.         sscanf (line, "%x",&dwDeviceID);
  526.     }
  527.     cards = AMCC_CountCards (dwVendorID, dwDeviceID);
  528.     if (cards==0) 
  529.     {
  530.         printf("%s", AMCC_ErrorString);
  531.         return NULL;
  532.     }
  533.     else if (cards==1) my_card = 1;
  534.     else
  535.     {
  536.         DWORD i;
  537.  
  538.         printf("Found %d matching PCI cards\n", cards);
  539.         printf("Select card (1-%d): ", cards);
  540.         i = 0;
  541.         fgets(line, sizeof(line), stdin);
  542.         sscanf (line, "%d",&i);
  543.         if (i>=1 && i <=cards) my_card = i;
  544.         else 
  545.         {
  546.             printf ("Choice out of range\n");
  547.             return NULL;
  548.         }
  549.     }
  550.     if (AMCC_Open (&hAmcc, dwVendorID, dwDeviceID, my_card - 1, fUseInt ? AMCC_OPEN_USE_INT : 0))
  551.         printf ("AMCC MatchMaker PCI card found!\n");
  552.     else printf ("%s", AMCC_ErrorString);
  553.     return hAmcc;
  554. }
  555.  
  556. int main(int argc, char *argv[])
  557. {
  558.     int cmd;
  559.     AMCCHANDLE hAmcc = NULL;
  560.     HANDLE hWD;
  561.     BOOL fUseInt = FALSE; // by default - do not install interrupts
  562.  
  563.     printf ("AMCC 5933 DK1 diagnostic utility.\n");
  564.     printf ("Application access hardware using " WD_PROD_NAME ".\n");
  565.  
  566.     // make sure WinDriver is loaded
  567.     if (!PCI_Get_WD_handle(&hWD)) return 0;
  568.     WD_Close (hWD);
  569.  
  570.     hAmcc = AMCC_LocateAndOpenBoard(0x10e8, 0x4750, fUseInt);
  571.  
  572.     do
  573.     {
  574.         printf ("\n");
  575.         printf ("AMCC 5933 main menu\n");
  576.         printf ("-------------------\n");
  577.         printf ("1. Scan PCI bus\n");
  578.         printf ("2. Set opening board %s interrupts\n", fUseInt ? "without" : "with");
  579.         printf ("3. Locate/Choose PCI matchmaker board (%s interrupts)\n", fUseInt ? "with" : "without");
  580.         if (hAmcc)
  581.         {
  582.             printf ("4. PCI configuration registers\n");
  583.             printf ("5. MatchMaker operation registers\n");
  584.             printf ("6. Access memory ranges on the board\n");
  585.             if (hAmcc->fUseInt)
  586.                 printf ("7. Enable / Disable interrupts\n");
  587.             printf ("8. Access nvRAM\n");
  588.             printf ("9. Run diagnostics\n");
  589.         }
  590.         printf ("99. Exit\n");
  591.         printf ("Enter option: ");
  592.         cmd = 0;
  593.         fgets(line, sizeof(line), stdin);
  594.         sscanf(line, "%d",&cmd);
  595.         switch (cmd)
  596.         {
  597.         case 1: // Scan PCI bus
  598.             PCI_Print_all_cards_info();
  599.             break;
  600.         case 2: // Set open board with / without interrupts
  601.             fUseInt = !fUseInt;
  602.             break;
  603.         case 3: // Locate PCI matchmaker board
  604.             if (hAmcc) AMCC_Close(hAmcc);
  605.             hAmcc = AMCC_LocateAndOpenBoard(0, 0, fUseInt);
  606.             if (!hAmcc) printf ("AMCC card open failed!\n");
  607.             break;
  608.         case 4: // PCI configuration registers
  609.             if (hAmcc) PCI_EditConfigReg(hAmcc->pciSlot);
  610.             break;
  611.         case 5: // MatchMaker operation registers
  612.             if (hAmcc) AMCC_EditReg(hAmcc);
  613.             break;
  614.         case 6: // MatchMaker access address spaces
  615.             if (hAmcc) AMCC_BoardAccess(hAmcc);
  616.             break;
  617.         case 7: // Enable / Disable interrupts
  618.             if (hAmcc && hAmcc->fUseInt) AMCC_EnableDisableInterrupts(hAmcc);
  619.             break;
  620.         case 8: // access nvRAM
  621.             if (hAmcc) AMCC_AccessNVRAM(hAmcc);
  622.             break;
  623.         case 9: // Run diagnostics
  624.             if (hAmcc) AMCC_RunDiag(hAmcc);
  625.             break;
  626.         }
  627.     } while (cmd!=99);
  628.  
  629.     if (hAmcc) AMCC_Close(hAmcc);
  630.  
  631.     return 0;
  632. }
  633.  
  634.                                       
  635.